home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / osi / isode / dosisode / DOSISODE80.ZIP / ISODE8.WRK / UNIX / LIB / SOCKET.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-19  |  13.5 KB  |  496 lines
  1. /* Emulation of 4.2 UNIX socket interface routines              */
  2. #include <stdio.h>
  3. #include <std.h>
  4. #include <dos.h>
  5. #include <errno.h>
  6. #include <fcntl.h>
  7. #include <sys/fcntl.h>
  8. #include <netdb.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <sys/ioctl.h>
  12. #include <sys/uio.h>
  13. #include <sys/time.h>
  14. #include <netinet/in.h>
  15. #include <netx25/x25_ctl.h>
  16. #include <netx25/x25_ioctl.h>
  17. #include <netx25/x25_pk.h>
  18. #include "si_header.h"
  19. #include "si_ip.h"
  20. SOCK __sock[_NFILE];
  21. extern int errno;
  22. extern int si_xlate[];
  23.  
  24. static int unreaddata(int);
  25. static int socket_close(int);
  26. static void set_echo(void);
  27. static void set_noecho(void);
  28. static int udp_create(int, int);
  29. static start_udp_read(int);
  30. static start_passive_open(int);
  31. static int accept_waiting(int);
  32. static int convert_errno(int);
  33. static void tcp_exit(void);
  34.  
  35. static int debug = 0;
  36. static int exit_flag = 0;
  37. static int unique = 0;
  38. static short retval;
  39. FILE *si_fopen();
  40. union REGS regs;
  41. char *dos_buffer;
  42.  
  43. union ioctl_arg {int i;struct sgttyb sg;struct ltchars t;};
  44. static struct sgttyb def_tty = {13, 13, 0x7f, 0x18, 0000010};
  45.  
  46. /************************************************************/
  47. /* socket routine                                           */
  48. /************************************************************/
  49. int socket(domain,type,protocol)
  50. int domain,type,protocol;
  51. {
  52.     FILE *fp;
  53.     int s;
  54.     char buffer[80], *getenv();
  55.  
  56.     unique++;
  57. if (debug) {fprintf(stderr,"socket open called\n");fflush(stderr);}
  58.     sprintf(buffer,"%s/si_file.%03d",getenv("TMP"),unique);
  59.     if ((fp = fopen(buffer,"w+")) == NULL) {
  60.         fprintf(stderr,"Can't create tempfile \\tmp\\si_file!\n");
  61.         fprintf(stderr,"Check the directory exists!\n");
  62.         exit(1);
  63.     }
  64.     s = fileno(fp);
  65.  
  66.     if (! exit_flag) {
  67.         atexit(tcp_exit);
  68.         exit_flag = 1;
  69.     }
  70.  
  71.     regs.x.ax = SI_CHECKLOAD;
  72.     int86(INTR,®s,®s);
  73.     if (regs.x.cx != 0x1234) {
  74.         fprintf(stderr,"'Sockets' TSR is not loaded!\n");
  75.         exit(1);
  76.     }
  77.     regs.x.ax = SI_SOCKET;
  78.     regs.x.cx = type;
  79.     regs.x.dx = s;
  80.     int86(INTR,®s,®s);
  81.     dos_buffer = (char *)(0xe0000000 + (regs.x.cx<<4) + regs.x.dx);
  82.     if (regs.x.ax == FAIL) {
  83.         close(s);
  84.         remove(buffer);
  85.         fprintf(stderr,"Can't allocate any more sockets %d %d!\n",regs.x.ax,FAIL);
  86.         errno = regs.x.cx;
  87.         return(-1);
  88.     }
  89.     __sock[s].unique = unique;
  90.     __sock[s].bit.in_use = 1;
  91.     si_xlate[s] = s;
  92.     return(s);
  93. }
  94.  
  95. /************************************************************/
  96. /* bind routine                                             */
  97. /************************************************************/
  98. int bind(s,name,namelen)
  99. int s;
  100. void *name;
  101. int namelen;
  102. {
  103.     struct sockaddr_in *sin;
  104.     sin = (struct sockaddr_in *)name;
  105.  
  106. if (debug) {fprintf(stderr,"socket bind called\n");fflush(stderr);}
  107.     bcopy((char *)name, dos_buffer,namelen);
  108.     regs.x.ax = SI_BIND;
  109.     regs.x.dx = si_x(s);
  110.     int86(INTR,®s,®s);
  111.     errno = regs.x.cx;
  112.     return((retval=regs.x.ax));
  113. }
  114.  
  115. /************************************************************/
  116. /* connect routine                                          */
  117. /************************************************************/
  118. int connect(s,name,namelen)
  119. int s;
  120. struct sockaddr *name;
  121. int namelen;
  122. {
  123.     short retval;
  124.     struct sockaddr_in *sin;
  125.     sin = (struct sockaddr_in *)name;
  126.  
  127. if (debug) {fprintf(stderr,"socket connect called\n");fflush(stderr);}
  128.     regs.x.ax = SI_CONNECT;
  129.     regs.x.dx = si_x(s);
  130.     bcopy((char *)name, dos_buffer, namelen);
  131.     int86(INTR,®s,®s);
  132.     errno = regs.x.cx;
  133.     return((retval=regs.x.ax));
  134. }
  135. /************************************************************/
  136. /* listen routine                                           */
  137. /************************************************************/
  138. int listen(s,backlog)
  139. int s;
  140. int backlog;
  141. {
  142. if (debug) {fprintf(stderr,"socket listen called 1\n");fflush(stderr);}
  143.  
  144.     regs.x.ax = SI_LISTEN;
  145.     regs.x.cx = backlog;
  146.     regs.x.dx = si_x(s);
  147.     int86(INTR,®s,®s);
  148.     errno = regs.x.cx;
  149.     return((retval=regs.x.ax));
  150. }
  151.  
  152. /************************************************************/
  153. /* accept routine                                           */
  154. /************************************************************/
  155. int accept(s, addr, addrlen)
  156. int s;
  157. struct sockaddr *addr;
  158. int *addrlen;
  159. {
  160.     int news;
  161.  
  162. if (debug) {fprintf(stderr,"socket accept called\n");fflush(stderr);}
  163.     news = dup(s);
  164.     if (news != -1) si_xlate[news] = news; /*!*/
  165.  
  166.     regs.x.ax = SI_ACCEPT;
  167.     regs.x.dx = s;
  168.     regs.x.cx = news;
  169.     int86(INTR,®s,®s);
  170.     errno = regs.x.cx;
  171.     if (regs.x.ax == FAIL) return(-1);
  172.     if (addr != NULL) {
  173.         *addrlen = sizeof (struct sockaddr_in);
  174.         bcopy(dos_buffer, (char *)addr, *addrlen);
  175.     }
  176.     return(news);
  177. }
  178.  
  179. /************************************************************/
  180. /* recv routine                                             */
  181. /************************************************************/
  182. int recv(s, buf, len, flags)
  183. int s;
  184. char *buf;
  185. int len, flags;
  186. {
  187.    return(recvfrom(s, buf, len, flags, NULL, NULL)); /*its just a subset*/
  188. }
  189.  
  190. /************************************************************/
  191. /* recvfrom routine                                         */
  192. /************************************************************/
  193. int recvfrom(s, buf, len, flags, from, fromlen)
  194. int s;
  195. char *buf;
  196. int len, flags;
  197. struct sockaddr *from;
  198. int *fromlen;
  199. {
  200. if (debug) fprintf(stderr,"recvfrom called\n");
  201.  
  202.     regs.x.ax = SI_RECVFROM;
  203.     regs.x.dx = si_x(s);
  204.     regs.x.cx = len;
  205.     int86(INTR,®s,®s);
  206.     errno = regs.x.cx;
  207.     if (regs.x.ax == FAIL) return(-1);
  208.     bcopy(dos_buffer+16, (char *)buf, regs.x.ax);
  209.     if (from != NULL) {
  210.         bcopy(dos_buffer, (char *)from, sizeof (struct sockaddr));
  211.         *fromlen = sizeof (struct sockaddr);
  212.     }
  213.     return((retval=regs.x.ax));
  214. }
  215.  
  216. /************************************************************/
  217. /* send routine                                             */
  218. /************************************************************/
  219. int send(s , buf, len, flags)
  220. int s;
  221. char *buf;
  222. int len, flags;
  223. {
  224.   return(sendto(s, buf, len, flags, NULL, NULL)); /*a subset of sendto */
  225. }
  226.  
  227. /************************************************************/
  228. /* sendto routine                                           */
  229. /************************************************************/
  230. int sendto(s, buf, len, flags, to, tolen)
  231. int s;
  232. char *buf;
  233. int len, flags;
  234. struct sockaddr *to;
  235. int tolen;
  236. {
  237. if (debug) fprintf(stderr,"sendo called len = %d\n",len);
  238.  
  239.     if (to != NULL) bcopy((char *)to, dos_buffer, sizeof (struct sockaddr));
  240.     bcopy((char *)buf, dos_buffer+16, len);
  241.     regs.x.ax = SI_SENDTO;
  242.     regs.x.dx = si_x(s);
  243.     regs.x.cx = len;
  244.     int86(INTR,®s,®s);
  245. if (debug) fprintf(stderr,"sendto returns %d %d\n",regs.x.ax,regs.x.cx);
  246.     errno = regs.x.cx;
  247.     if (regs.x.ax == FAIL) return(-1);
  248.     bcopy(buf, dos_buffer+16, regs.x.ax);
  249.     return((retval=regs.x.ax));
  250. }
  251.  
  252. /************************************************************/
  253. /* getsockname routine                                      */
  254. /************************************************************/
  255. int getsockname(s,name,namelen)
  256. int s;
  257. struct sockaddr_in *name;
  258. int *namelen;
  259. {
  260.  
  261.     *namelen = sizeof(*name);
  262.     name->sin_family = AF_INET;
  263.     name->sin_port = 0;/*xxxx*/
  264.     return(0);
  265. }
  266.  
  267. /************************************************************/
  268. /* select routine                                           */
  269. /************************************************************/
  270. int select(nfds,readfds,writefds,exceptfds,timeout)
  271. int nfds;
  272. fd_set *readfds,*writefds,*exceptfds;
  273. struct timeval *timeout;
  274. {
  275.     static fd_set new_readfds, new_writefds, new_exceptfds;
  276.     int total;
  277.     short int secs;
  278.     int x,y,z;
  279.  
  280.     bzero(dos_buffer,32);
  281.     if (readfds) bcopy((char *)readfds, dos_buffer, 4);
  282.     if (writefds) bcopy((char *)writefds, dos_buffer+4, 4);
  283.     if (exceptfds) bcopy((char *)exceptfds, dos_buffer+8, 4);
  284.     if (timeout) secs = timeout->tv_sec;
  285.     else secs = -1;
  286.     bcopy((char *)&secs, dos_buffer+12, 2);
  287.  
  288.     regs.x.ax = SI_SELECT;
  289.     regs.x.dx = nfds;
  290.     int86(INTR,®s,®s);
  291.     total = regs.x.ax;
  292.     if (readfds) bcopy(dos_buffer, (char *)readfds, 4);
  293.     if (writefds) bcopy(dos_buffer+4, (char *)writefds, 4);
  294.     if (exceptfds) bcopy(dos_buffer+8, (char *)exceptfds, 4);
  295.     bcopy(dos_buffer, (char *)&x, 4);
  296.     bcopy(dos_buffer+4, (char *)&y, 4);
  297.     bcopy(dos_buffer+8, (char *)&z, 4);
  298. if (debug) {fprintf(stderr,"select returns %d r=%x w=%x e=%x\n",total,x,y,z);fflush(stderr);}
  299.     return(total);
  300. }
  301.  
  302. /************************************************************/
  303. /* si_ioctl routine                                            */
  304. /************************************************************/
  305. si_ioctl(s,request,argp)
  306. int s;
  307. unsigned long request;
  308. union ioctl_arg *argp;
  309. {
  310. if (debug) fprintf(stderr,"ioctl called - request=%d (FIONBIO=%d)\n",request,FIONBIO);
  311.     if (request == SIOCSPGRP) {
  312.         return(0);
  313.     }
  314. #ifdef FIONBIO
  315.     if (request == FIONBIO) {
  316.         regs.x.ax = SI_IOCTL;
  317.         regs.x.dx = si_x(s);
  318.         int86(INTR,®s,®s);
  319.     }
  320. #endif
  321.     if (request == FIONREAD) {
  322.         argp->i = 1; /*xxxx*/
  323.         return(0);
  324.     }
  325.     if (request == TIOCGETP) {
  326.         argp->sg.sg_ispeed = def_tty.sg_ispeed;
  327.         argp->sg.sg_ospeed = def_tty.sg_ospeed;
  328.         argp->sg.sg_erase = def_tty.sg_erase;
  329.         argp->sg.sg_kill  = def_tty.sg_kill;
  330.         argp->sg.sg_flags = def_tty.sg_flags;
  331.         return(0);
  332.     }
  333.     if (request == TIOCSETP) {
  334.         def_tty.sg_ispeed = argp->sg.sg_ispeed;
  335.         def_tty.sg_ospeed = argp->sg.sg_ospeed;
  336.         def_tty.sg_erase = argp->sg.sg_erase;
  337.         def_tty.sg_kill = argp->sg.sg_kill;
  338.         def_tty.sg_flags = argp->sg.sg_flags;
  339.         if ( (def_tty.sg_flags & ECHO) == ECHO ) set_echo();
  340.         else set_noecho();
  341.         return(0);
  342.     }
  343.     if (request == TIOCGLTC) {
  344.         argp->t.t_suspc = 0x19;
  345.         argp->t.t_dsuspc = 0x19;
  346.         argp->t.t_rprntc = 0xff;
  347.         argp->t.t_flushc = 0xff;
  348.         argp->t.t_werasc = 0xff;
  349.         argp->t.t_lnextc = 0x0;
  350.         return(0);
  351.     }
  352.     if (request == TIOCSLTC) {
  353.         return(0);
  354.     }
  355. }
  356. /************************************************************/
  357. /* set_echo routine                                            */
  358. /************************************************************/
  359. static void set_echo()
  360. {
  361. /*can't think how to do this*/
  362. }
  363.  
  364. /************************************************************/
  365. /* set_noecho routine                                           */
  366. /************************************************************/
  367. static void set_noecho()
  368. {
  369. }
  370.  
  371. /************************************************************/
  372. /* shutdown routine                                         */
  373. /************************************************************/
  374. shutdown(s,how)
  375. int s,how;
  376. {
  377. if (debug) fprintf(stderr,"shutdown called\n");
  378. }
  379.  
  380. /************************************************************/
  381. /* getsockopt routine                                       */
  382. /************************************************************/
  383. getsockopt(s,level,optname,optval,optlen)
  384. int s, level, optname;
  385. char *optval;
  386. int *optlen;
  387. {
  388.     return(0);
  389. }
  390.  
  391. /************************************************************/
  392. /* setsockopt routine                                       */
  393. /************************************************************/
  394. setsockopt(s,level,optname,optval,optlen)
  395. int s, level, optname;
  396. char *optval;
  397. int optlen;
  398. {
  399.     return(0);
  400. }
  401.  
  402. /************************************************************/
  403. /* sigvec - must remember name of function to be called   */
  404. /************************************************************/
  405. sigvec(sig,vec,ovec)
  406. int sig;
  407. struct sigvec *vec, *ovec;
  408. {
  409. if (debug) fprintf(stderr,"sigvec called\n");
  410. }
  411.  
  412. /************************************************************/
  413. /* alarm - insert a call to our own alarm function        */
  414. /************************************************************/
  415. unsigned alarm(i)
  416. unsigned i;
  417. {
  418. if (debug) fprintf(stderr,"alarm called\n");
  419. }
  420.  
  421. static struct hostent my_hostent;
  422.  
  423. /************************************************************/
  424. /* stty - obsolete form of ioctl                            */
  425. /************************************************************/
  426. stty(fd,buf)
  427. int fd;
  428. struct sgttyb *buf;
  429. {
  430.     return(si_ioctl(fd, TIOCSETP, (union ioctl_arg *)buf));
  431. }
  432.  
  433. /************************************************************/
  434. /* gtty - obsolete form of ioctl                            */
  435. /************************************************************/
  436. gtty(fd,buf)
  437. int fd;
  438. struct sgttyb *buf;
  439. {
  440.     return(si_ioctl(fd, TIOCGETP, (union ioctl_arg *)buf));
  441. }
  442.  
  443. /************************************************************/
  444. /*  si_close - new close routine                */
  445. /************************************************************/
  446.  
  447. si_close(s)
  448. int s;
  449. {
  450.     if (__sock[s].unique) socket_close(s);
  451.     __sock[s].unique = 0;
  452.     __sock[s].bit.in_use = 0;
  453.     si_xlate[s] = s;
  454.     return(close(s));
  455. }
  456.  
  457. /************************************************************/
  458. /*  socket_close - close socket                    */
  459. /************************************************************/
  460.  
  461. socket_close(s)
  462. int s;
  463. {
  464.     char buffer[80];
  465.  
  466. if (debug) fprintf(stderr,"socket close called s = %d\n",s);
  467.     close(s);
  468.     sprintf(buffer,"%s/si_file.%03d",getenv("TMP"),__sock[s].unique);
  469.     remove(buffer);
  470.     regs.x.ax = SI_CLOSE;
  471.     regs.x.dx = s;
  472.     int86(INTR,®s,®s);
  473.     errno = regs.x.cx;
  474.     return((retval=regs.x.ax));
  475. }
  476. int gethostaddr()
  477. {
  478. }
  479.  
  480. gethostname(name, namelen)
  481. char *name;
  482. int namelen;
  483. {
  484.     strncpy(name,getenv("HOSTNAME"),namelen);
  485.     return;
  486. }
  487.  
  488. void tcp_exit()
  489. {
  490.     int s;
  491.  
  492.     for (s=0;s<_NFILE;s++) if (__sock[s].unique) si_close(s);
  493.     regs.x.ax = SI_SHUTDOWN;
  494.     int86(INTR,®s,®s);
  495. }
  496.